home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / clang / cslib15b.zip / DEMO / ADDRESS / CSADDIO.CPP < prev    next >
C/C++ Source or Header  |  1994-12-20  |  20KB  |  656 lines
  1. #include "csaddio.h"
  2.  
  3. extern unsigned _stklen=7000;  //A large stack is needed
  4.  
  5. ////////////// The used .def file is included as comment ////////
  6. /*
  7. class: NAM_foundation
  8. record: record
  9. file: csadr.dbf
  10. field: name s 40 T
  11. field: adre s 32
  12. field: city s 23 Y
  13. field: count s 32
  14. field: zip s 9
  15. field: tel s 17
  16. field: update d MDY2
  17. field: birth d DMY4 Y
  18. field: relation s 10 Y
  19. field: info s 70
  20. */
  21. /////////////// End of .def file //////////////////////////////////////////////
  22.  
  23. ///////////////////////////////// Constructor ////////////////////////////////
  24. NAM_foundation::NAM_foundation(void) 
  25. { 
  26.     is_open=FALSE; 
  27.     current=1; 
  28.     _update.format(MDY2); 
  29.     _birth.format(DMY4); 
  30. }
  31.  
  32. ///////////////////////////////// reindex ////////////////////////////////////
  33. void NAM_foundation::reindex(void) 
  34. {
  35.     U32 l=current;  
  36.     record *rp;  
  37.     in1.empty(); 
  38.     in2.empty(); 
  39.     in3.empty(); 
  40.     in4.empty(); 
  41.     for(current=numrec(); current>0; current--)  
  42.     {                          
  43.        rp=(record *)db.locate_rec(current);  
  44.        tokenize(rp->_name,&NAM_foundation::in1_ins_tok); 
  45.        in2.insert(rp->_city,¤t); 
  46.        in3.insert(&rp->__birth,¤t); 
  47.        in4.insert(rp->_relation,¤t); 
  48.     }                          
  49.     current=l;                 
  50. }
  51.  
  52. /////////////// append blank//////////////////////////////////////
  53. void NAM_foundation::append_blank(void) 
  54. {
  55.        append();
  56.        tokenize(recp->_name,&NAM_foundation::in1_ins_tok); 
  57.        in2.insert(rec._city,¤t); 
  58.        in3.insert(&rec.__birth,¤t); 
  59.        in4.insert(rec._relation,¤t); 
  60. }
  61.  
  62. ///////////////////////////////// append /////////////////////////////////////
  63. // This function doesn't update the indexes, which can save some 
  64. // disk I/O because you are likely to alter the fields 
  65. // immediatly after you have appended the record.
  66. // However, if you have an index on a field you don't update, this 
  67. // record will NOT appear in that particularly index! 
  68. // The 'append_blank' function does update all indexes, which 
  69. // makes it a safer, but slower option. 
  70. //  
  71. void NAM_foundation::append(void) 
  72. {
  73.     write_rec();
  74.     memset(&rec,0,sizeof(record)); 
  75.     current=db.append_rec(&rec); 
  76.     recp=(record *)db.locate_rec(current); 
  77.     dirty=TRUE;    
  78.     _update.sem_jul(0L);
  79.     _birth.sem_jul(0L);
  80. }
  81.  
  82. ///////////////////////////////// open ///////////////////////////////////////
  83. void NAM_foundation::open(void) 
  84. {
  85.      if(is_open) return; 
  86.      int needs_reindex=FALSE;        
  87.      dirty=FALSE;        
  88.  
  89. #ifdef _Windows
  90.      int fre=300/9; //Use 300 kB for buffers. You may increase this.
  91. #else
  92.      int fre=(int)(coreleft()-100000L)/9/1024;
  93.      fre=max(fre,0); 
  94. #endif
  95.  
  96.      if(!db.open("csadr.dbf",fre)) 
  97.      {
  98.          csmess_disp("FATAL: Can't open database csadr.dbf.");
  99.          exit(1);
  100.      }
  101.      if(db.lengthrec()!=sizeof(record)) 
  102.      {
  103.          csmess_disp("FATAL: wrong record size.\n\rProbably wrong or old database file.");
  104.          db.close(); 
  105.          exit(1); 
  106.      }
  107.      if(!file_exist("csadr01.idx"))
  108.      { 
  109.        in1.multiple_keys(TRUE);
  110.        in1.define("csadr01.idx",NAME_LENGTH+1,sizeof(long));
  111.        needs_reindex=TRUE; 
  112.      } 
  113.      in1.open("csadr01.idx",fre*2);
  114.   
  115.      if(!file_exist("csadr02.idx"))
  116.      { 
  117.        in2.multiple_keys(TRUE);
  118.        in2.define("csadr02.idx",CITY_LENGTH+1,sizeof(long));
  119.        needs_reindex=TRUE; 
  120.      } 
  121.      in2.open("csadr02.idx",fre*2);
  122.   
  123.      if(!file_exist("csadr03.idx"))
  124.      { 
  125.        in3.multiple_keys(TRUE);
  126.        in3.define("csadr03.idx",sizeof(long),sizeof(long));
  127.        needs_reindex=TRUE; 
  128.      } 
  129.      in3.open("csadr03.idx",fre*2);
  130.   
  131.      if(!file_exist("csadr04.idx"))
  132.      { 
  133.        in4.multiple_keys(TRUE);
  134.        in4.define("csadr04.idx",RELATION_LENGTH+1,sizeof(long));
  135.        needs_reindex=TRUE; 
  136.      } 
  137.      in4.open("csadr04.idx",fre*2);
  138.   
  139.      if(needs_reindex) reindex(); 
  140.      is_open=TRUE; 
  141.      if(numrec()==0) append_blank();
  142.      else            read_rec(); 
  143.   
  144.      order(UNSORTED);  
  145. }
  146.  
  147. ///////////////////////////////// close //////////////////////////////////////
  148. void NAM_foundation::close(void) 
  149. {
  150.      if(!is_open) return; 
  151.      write_rec(); 
  152.      db.close(); 
  153.      in1.close();
  154.      in2.close();
  155.      in3.close();
  156.      in4.close();
  157.      is_open=FALSE; 
  158. }
  159.  
  160. ///////////////////////////////// define /////////////////////////////////////
  161. void NAM_foundation::define(void) 
  162. {
  163.      db.define("csadr.dbf",sizeof(record)); 
  164.      in1.multiple_keys(TRUE);
  165.      in1.define("csadr01.idx",NAME_LENGTH+1,sizeof(long));
  166.      in2.multiple_keys(TRUE);
  167.      in2.define("csadr02.idx",CITY_LENGTH+1,sizeof(long));
  168.      in3.multiple_keys(TRUE);
  169.      in3.define("csadr03.idx",sizeof(long),sizeof(long));
  170.      in4.multiple_keys(TRUE);
  171.      in4.define("csadr04.idx",RELATION_LENGTH+1,sizeof(long));
  172. }
  173.  
  174. ///////////////////////////////// pack ///////////////////////////////////////
  175. void NAM_foundation::pack(void) 
  176. {
  177.      write_rec(); 
  178.      db.pack();
  179.      reindex();
  180.      if(numrec()==0) append_blank();
  181.      top();
  182. }
  183.  
  184. ///////////////////////////////// skip ///////////////////////////////////////
  185. int  NAM_foundation::skip(int delta) 
  186. {
  187.      long tmp_curr=curr_rec(); 
  188.      write_rec(); 
  189.      (this->*skip_fun)(delta); 
  190.      read_rec(); 
  191.      return (int)(curr_rec()-tmp_curr); 
  192. }
  193.  
  194. ///////////////////////////////// order //////////////////////////////////////
  195. void NAM_foundation::order(int nr) 
  196. {
  197.      switch(nr)
  198.      {
  199.          case 0:        //Unsorted 
  200.                   skip_fun  =&NAM_foundation::skip0;
  201.                   top_fun   =&NAM_foundation::top0;
  202.                   bottom_fun=&NAM_foundation::bottom0;
  203.                   search_fun=&NAM_foundation::search0;
  204.                   break; 
  205.          case 1:        //Index on field name
  206.                   skip_fun  =&NAM_foundation::skip1;
  207.                   top_fun   =&NAM_foundation::top1;
  208.                   bottom_fun=&NAM_foundation::bottom1;
  209.                   search_fun=&NAM_foundation::search1;
  210.                   break; 
  211.          case 2:        //Index on field city
  212.                   skip_fun  =&NAM_foundation::skip2;
  213.                   top_fun   =&NAM_foundation::top2;
  214.                   bottom_fun=&NAM_foundation::bottom2;
  215.                   search_fun=&NAM_foundation::search2;
  216.                   break; 
  217.          case 3:        //Index on field birth
  218.                   skip_fun  =&NAM_foundation::skip3;
  219.                   top_fun   =&NAM_foundation::top3;
  220.                   bottom_fun=&NAM_foundation::bottom3;
  221.                   search_fun=&NAM_foundation::search3;
  222.                   break; 
  223.          case 4:        //Index on field relation
  224.                   skip_fun  =&NAM_foundation::skip4;
  225.                   top_fun   =&NAM_foundation::top4;
  226.                   bottom_fun=&NAM_foundation::bottom4;
  227.                   search_fun=&NAM_foundation::search4;
  228.                   break; 
  229.      }
  230.      top();
  231. }
  232. /////////////////////////////writing record  ///////////////////////////////
  233. void NAM_foundation::write_rec2(void) 
  234. {
  235.     if(strcmp(recp->_name,rec._name)) 
  236.     { 
  237.       tokenize(recp->_name,&NAM_foundation::in1_del_tok); 
  238.       tokenize(rec._name,&NAM_foundation::in1_ins_tok); 
  239.     } 
  240.     if(strcmp(recp->_city,rec._city)) 
  241.     { 
  242.       in2.delet(recp->_city,¤t); 
  243.       in2.insert(rec._city,¤t); 
  244.     } 
  245.     rec.__update=_update.sem_jul(); 
  246.     rec.__birth=_birth.sem_jul(); 
  247.     if(recp->__birth!=rec.__birth) 
  248.     { 
  249.       in3.delet(&recp->__birth,¤t); 
  250.       in3.insert(&rec.__birth,¤t); 
  251.     } 
  252.     if(strcmp(recp->_relation,rec._relation)) 
  253.     { 
  254.       in4.delet(recp->_relation,¤t); 
  255.       in4.insert(rec._relation,¤t); 
  256.     } 
  257.     db.write_rec(current,&rec); 
  258.     dirty=FALSE;   
  259. }
  260.  
  261. ///////////////////////////////// export /////////////////////////////////////
  262. int  NAM_foundation::export(char *s) 
  263. {
  264.      FILE *fo=fopen(s,"w"); 
  265.      if(fo==NULL) return FALSE; 
  266.  
  267.      write_rec();
  268.      fprintf(fo,"class:  NAM_foundation");
  269.      fprintf(fo,"\nrecord: record");
  270.      fprintf(fo,"\nfile:   csadr.dbf");
  271.      fprintf(fo,"\nfield:  name s 40 Y");
  272.      fprintf(fo,"\nfield:  adre s 32  ");
  273.      fprintf(fo,"\nfield:  city s 23 Y");
  274.      fprintf(fo,"\nfield:  count s 32  ");
  275.      fprintf(fo,"\nfield:  zip s 9  ");
  276.      fprintf(fo,"\nfield:  tel s 17  ");
  277.      fprintf(fo,"\nfield:  update d  ");
  278.      fprintf(fo,"\nfield:  birth d Y");
  279.      fprintf(fo,"\nfield:  relation s 10 Y");
  280.      fprintf(fo,"\nfield:  info s 70  ");
  281.  
  282.      if(ferror(fo)) { fclose(fo); return FALSE; } 
  283.  
  284.      record *recp;
  285.      DATE conv;
  286.      conv.format(Y4MD);
  287.      for(long l=numrec();l>0;l--) 
  288.      {
  289.         recp=( record * )db.locate_rec(l);
  290.         fprintf(fo,"\n%c",12);
  291.         fprintf(fo,"\n%s",recp->_name);
  292.         fprintf(fo,"\n%s",recp->_adre);
  293.         fprintf(fo,"\n%s",recp->_city);
  294.         fprintf(fo,"\n%s",recp->_count);
  295.         fprintf(fo,"\n%s",recp->_zip);
  296.         fprintf(fo,"\n%s",recp->_tel);
  297.         conv.sem_jul(recp->__update);
  298.         fprintf(fo,"\n%s",(char *)conv);
  299.         conv.sem_jul(recp->__birth);
  300.         fprintf(fo,"\n%s",(char *)conv);
  301.         fprintf(fo,"\n%s",recp->_relation);
  302.         fprintf(fo,"\n%s",recp->_info);
  303.         fprintf(fo,"\n"); //Additional linefeed, to avoid trouble!
  304.  
  305.         if(ferror(fo)) { fclose(fo); return FALSE; } 
  306.      }
  307.      return !fclose(fo);  
  308. }
  309.  
  310. ///////////////////////////////// import /////////////////////////////////////
  311. int NAM_foundation::import(char *s) 
  312. {   
  313.  
  314.       FILE *fr=fopen(s,"r"); 
  315.       if(fr==NULL) return FALSE;
  316.   
  317.   
  318. #define MAX_NUM_FIELDS  100   //Increase this to allow more fields    
  319. #define MAX_FIELD_LEN   500   //Increase this to allow longer fields  
  320.  
  321.       int *finu;
  322.       finu=(int *)malloc(MAX_NUM_FIELDS*sizeof(int));
  323.       if(finu==NULL) { fclose(fr); return FALSE; }   
  324.  
  325.       char *fibu;    
  326.       fibu=(char *)malloc(MAX_FIELD_LEN);
  327.       if(fibu==NULL) { fclose(fr); free(finu); return FALSE; } 
  328.       *fibu=0;  
  329.  
  330.       char *fipo=fibu+strlen("field:");  
  331.       char *cp; 
  332.       int  ifieldnr=0;    
  333.       int  ofieldnr; 
  334.       DATE conv;
  335.       conv.format(Y4MD);
  336.  
  337.       memset(finu,0,MAX_NUM_FIELDS*sizeof(int));
  338.  
  339.       fgets(fibu,MAX_FIELD_LEN,fr); 
  340.       while(!strchr(fibu,12))  
  341.       {    
  342.         strlwr(fibu);
  343.         notabs(fibu);
  344.         trim_string(fibu);
  345.         if(strstr(fibu,"field:"))   
  346.         {  
  347.            ifieldnr++;  
  348.            trim_string(fipo);    
  349.            if((cp=strchr(fipo,' '))!=NULL) *cp=0;
  350.            if     (!strcmp(fipo,"name"))    ofieldnr=1;
  351.            else if(!strcmp(fipo,"adre"))    ofieldnr=2;
  352.            else if(!strcmp(fipo,"city"))    ofieldnr=3;
  353.            else if(!strcmp(fipo,"count"))    ofieldnr=4;
  354.            else if(!strcmp(fipo,"zip"))    ofieldnr=5;
  355.            else if(!strcmp(fipo,"tel"))    ofieldnr=6;
  356.            else if(!strcmp(fipo,"update"))    ofieldnr=7;
  357.            else if(!strcmp(fipo,"birth"))    ofieldnr=8;
  358.            else if(!strcmp(fipo,"relation"))    ofieldnr=9;
  359.            else if(!strcmp(fipo,"info"))    ofieldnr=10;
  360.            else ofieldnr=0; 
  361.            finu[ifieldnr]=ofieldnr; 
  362.         }  
  363.         fgets(fibu,MAX_FIELD_LEN,fr);    
  364.       }    
  365.  
  366.  
  367.  
  368.       for(;;)   
  369.       {    
  370.         if(!strchr(fibu,12))   
  371.         {  
  372.            ifieldnr++; 
  373.            if(ifieldnr<MAX_NUM_FIELDS) 
  374.              switch(finu[ifieldnr])   
  375.              {  
  376.                 case 0:  break;
  377.                 case 1:
  378.                          fibu[NAME_LENGTH]=0;
  379.                          name(fibu);
  380.                          break;
  381.                 case 2:
  382.                          fibu[ADRE_LENGTH]=0;
  383.                          adre(fibu);
  384.                          break;
  385.                 case 3:
  386.                          fibu[CITY_LENGTH]=0;
  387.                          city(fibu);
  388.                          break;
  389.                 case 4:
  390.                          fibu[COUNT_LENGTH]=0;
  391.                          count(fibu);
  392.                          break;
  393.                 case 5:
  394.                          fibu[ZIP_LENGTH]=0;
  395.                          zip(fibu);
  396.                          break;
  397.                 case 6:
  398.                          fibu[TEL_LENGTH]=0;
  399.                          tel(fibu);
  400.                          break;
  401.                 case 7:
  402.                          conv=fibu;
  403.                          _update.sem_jul(conv.sem_jul());
  404.                          break;
  405.                 case 8:
  406.                          conv=fibu;
  407.                          _birth.sem_jul(conv.sem_jul());
  408.                          break;
  409.                 case 9:
  410.                          fibu[RELATION_LENGTH]=0;
  411.                          relation(fibu);
  412.                          break;
  413.                 case 10:
  414.                          fibu[INFO_LENGTH]=0;
  415.                          info(fibu);
  416.                          break;
  417.              }  
  418.         }  
  419.         else    
  420.         {  
  421.            ifieldnr=0; 
  422.            append_blank();
  423.         }  
  424.         if(feof(fr)) break;    
  425.         fgets(fibu,MAX_FIELD_LEN,fr);    
  426.         cp=fibu+(max(1,strlen(fibu))-1); 
  427.         if(*cp=='\n') *cp=0;  //removing the line feed 
  428.       }    
  429.  
  430.  
  431.       fclose(fr); 
  432.       free(fibu); 
  433.       free(finu); 
  434.  
  435. #undef MAX_NUM_FIELDS
  436. #undef MAX_FIELD_LEN 
  437.  
  438.  return TRUE; 
  439. }
  440.  
  441. ///////////////////////////////// export to dBASE compatible file. ///////////
  442. int NAM_foundation::to_DBASE(char *s) 
  443. {   
  444.  
  445.       char bufje[12];
  446.       if(!is_open) return FALSE;
  447.  
  448.       write_rec(); 
  449.       FILE *fo=fopen(s,"wb"); 
  450.       if(fo==NULL) return FALSE;
  451.   
  452.       int i;
  453.   
  454.       DATE d_upda;
  455.       d_upda.sem_jul(db.sj_updated());
  456.       fputc(03,fo);  
  457.       
  458.       fputc(d_upda.year()%100,fo);  
  459.       fputc(d_upda.month(),fo);  
  460.       fputc(d_upda.day(),fo);  
  461.  
  462.       long nr_record=numrec(); 
  463.       fwrite(&nr_record,sizeof(long),1,fo); 
  464.       putw(354,fo);        //Header length 
  465.       putw(250,fo);        //Length of data record 
  466.       for(i=0;i<20;i++) fputc(0,fo); // 20 dummy bytes 
  467.  
  468.  
  469. // Writing definition of field name to dbase file header.
  470.       memset(bufje,0,11);
  471.       strcpy(bufje,"NAME");
  472.       fwrite(bufje,11,1,fo);
  473.       fputc('C',fo); 
  474.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  475.       fputc(40,fo); 
  476.       fputc(0,fo); 
  477.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  478.  
  479. // Writing definition of field adre to dbase file header.
  480.       memset(bufje,0,11);
  481.       strcpy(bufje,"ADRE");
  482.       fwrite(bufje,11,1,fo);
  483.       fputc('C',fo); 
  484.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  485.       fputc(32,fo); 
  486.       fputc(0,fo); 
  487.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  488.  
  489. // Writing definition of field city to dbase file header.
  490.       memset(bufje,0,11);
  491.       strcpy(bufje,"CITY");
  492.       fwrite(bufje,11,1,fo);
  493.       fputc('C',fo); 
  494.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  495.       fputc(23,fo); 
  496.       fputc(0,fo); 
  497.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  498.  
  499. // Writing definition of field count to dbase file header.
  500.       memset(bufje,0,11);
  501.       strcpy(bufje,"COUNT");
  502.       fwrite(bufje,11,1,fo);
  503.       fputc('C',fo); 
  504.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  505.       fputc(32,fo); 
  506.       fputc(0,fo); 
  507.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  508.  
  509. // Writing definition of field zip to dbase file header.
  510.       memset(bufje,0,11);
  511.       strcpy(bufje,"ZIP");
  512.       fwrite(bufje,11,1,fo);
  513.       fputc('C',fo); 
  514.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  515.       fputc(9,fo); 
  516.       fputc(0,fo); 
  517.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  518.  
  519. // Writing definition of field tel to dbase file header.
  520.       memset(bufje,0,11);
  521.       strcpy(bufje,"TEL");
  522.       fwrite(bufje,11,1,fo);
  523.       fputc('C',fo); 
  524.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  525.       fputc(17,fo); 
  526.       fputc(0,fo); 
  527.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  528.  
  529. // Writing definition of field update to dbase file header.
  530.       memset(bufje,0,11);
  531.       strcpy(bufje,"UPDATE");
  532.       fwrite(bufje,11,1,fo);
  533.       fputc('D',fo); 
  534.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  535.       fputc(8,fo); 
  536.       fputc(0,fo); 
  537.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  538.  
  539. // Writing definition of field birth to dbase file header.
  540.       memset(bufje,0,11);
  541.       strcpy(bufje,"BIRTH");
  542.       fwrite(bufje,11,1,fo);
  543.       fputc('D',fo); 
  544.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  545.       fputc(8,fo); 
  546.       fputc(0,fo); 
  547.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  548.  
  549. // Writing definition of field relation to dbase file header.
  550.       memset(bufje,0,11);
  551.       strcpy(bufje,"RELATION");
  552.       fwrite(bufje,11,1,fo);
  553.       fputc('C',fo); 
  554.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  555.       fputc(10,fo); 
  556.       fputc(0,fo); 
  557.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  558.  
  559. // Writing definition of field info to dbase file header.
  560.       memset(bufje,0,11);
  561.       strcpy(bufje,"INFO");
  562.       fwrite(bufje,11,1,fo);
  563.       fputc('C',fo); 
  564.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  565.       fputc(70,fo); 
  566.       fputc(0,fo); 
  567.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  568.  
  569.  
  570.       fputc(13,fo);  //Field terminator 
  571.       fputc(0,fo); 
  572.  
  573. // By now we have written the definition of the file structure 
  574. // to the file header. 
  575. // From here on we will export the records. 
  576.  
  577.      record *recp;
  578.      for(long l=numrec();l>0;l--) 
  579.      {
  580.  
  581.         if(ferror(fo)) { fclose(fo); return FALSE; } 
  582.         recp=(record *)db.locate_rec(l);
  583.  
  584.         if(db.is_delet(l)) fputc(42,fo); 
  585.         else               fputc(32,fo); 
  586.  
  587. /////////////////////// writing field name /////////////
  588.         fprintf(fo,"%-40s",recp->_name);
  589. /////////////////////// writing field adre /////////////
  590.         fprintf(fo,"%-32s",recp->_adre);
  591. /////////////////////// writing field city /////////////
  592.         fprintf(fo,"%-23s",recp->_city);
  593. /////////////////////// writing field count /////////////
  594.         fprintf(fo,"%-32s",recp->_count);
  595. /////////////////////// writing field zip /////////////
  596.         fprintf(fo,"%-9s",recp->_zip);
  597. /////////////////////// writing field tel /////////////
  598.         fprintf(fo,"%-17s",recp->_tel);
  599. /////////////////////// writing field update /////////////
  600.         if(recp->__update)
  601.         { 
  602.           d_upda.sem_jul(recp->__update);
  603.           fprintf(fo,"%4d",d_upda.year4());
  604.           fprintf(fo,"%02d",d_upda.month());
  605.           fprintf(fo,"%02d",d_upda.day());
  606.         } 
  607.         else 
  608.         { 
  609.           fprintf(fo,"        "); 
  610.         } 
  611. /////////////////////// writing field birth /////////////
  612.         if(recp->__birth)
  613.         { 
  614.           d_upda.sem_jul(recp->__birth);
  615.           fprintf(fo,"%4d",d_upda.year4());
  616.           fprintf(fo,"%02d",d_upda.month());
  617.           fprintf(fo,"%02d",d_upda.day());
  618.         } 
  619.         else 
  620.         { 
  621.           fprintf(fo,"        "); 
  622.         } 
  623. /////////////////////// writing field relation /////////////
  624.         fprintf(fo,"%-10s",recp->_relation);
  625. /////////////////////// writing field info /////////////
  626.         fprintf(fo,"%-70s",recp->_info);
  627.      }
  628.      fputc(26,fo);  //End of File 
  629.      fclose(fo); 
  630.  
  631.  return TRUE; 
  632. }
  633.  
  634. ///////////////////////////////// tokenize field ///////////////////////
  635. void NAM_foundation::tokenize(char *s,void(NAM_foundation::*fun)(void *))
  636. {
  637.  
  638.      char delim[]="\t,() "; //Token delimiters
  639.      char *p,*q=s;
  640.      char c;
  641.      int  insert=FALSE;
  642.      const min_len=4;  //Minimum length for a token to be indexed.
  643.  
  644.      p=strpbrk(q,delim);
  645.      while(p)
  646.      {
  647.         c=*p; *p=0;
  648.         if(strlen(q)>=min_len) { (this->*fun)(q); insert=TRUE; }
  649.         *p=c;
  650.         do{ p=strpbrk(q=p+1,delim); }while(q==p);
  651.      }
  652.  
  653.      if(strlen(q)>=min_len) { (this->*fun)(q); insert=TRUE; }
  654.      if(!insert) (this->*fun)(s);
  655.  
  656. }